home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / MacPerl 5.1.3 / Mac_Perl_513_src / perl5.002 / missing.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-17  |  12.3 KB  |  675 lines  |  [TEXT/MPS ]
  1. /* $Header: tyrathect:Development:Perl::RCS:missing.c,v 1.2 1994/05/04 02:12:43 neeri Exp $
  2.  *
  3.  *    Copyright (c) 1991-1994 Matthias Neeracher
  4.  *
  5.  *    You may distribute under the terms of the Perl Artistic License,
  6.  *    as specified in the README file.
  7.  *
  8.  * $Log: missing.c,v $
  9.  * Revision 1.2  1994/05/04  02:12:43  neeri
  10.  * Added gmtime(), enabled utime(), reduced spinning.
  11.  *
  12.  * Revision 1.1  1994/03/01  23:38:17  neeri
  13.  * Initial revision
  14.  *
  15.  */
  16.  
  17. /* NEVER try including perl.h here ! */
  18.  
  19. /* DISPATCH_START */
  20. #define MAC_CONTEXT
  21. #define MP_EXT
  22. #define MP_INIT(x) = x
  23.  
  24. #include <time.h>
  25. #include <stdio.h>
  26. #include <AppleEvents.h>
  27. #include <Folders.h>
  28. #include <Events.h>
  29. #include <OSUtils.h>
  30. #include <LowMem.h>
  31. #include <GUSI.h>
  32. #include <TFileSpec.h>
  33. #include <TFileGlob.h>
  34. #include <fp.h>
  35. #include <LowMem.h>
  36.  
  37. #define MEM_SIZE    Size_t
  38.  
  39. #include "config.h"
  40. #include "handy.h"
  41. #include "macish.h"
  42. #include "SubLaunch.h"
  43. #include "embed.h"
  44. /* DISPATCH_END */
  45.  
  46. /* Calls that don't exist on the mac */
  47.  
  48. /* Borrowed from msdos.c
  49.  * Just pretend that everyone is a superuser
  50.  */
  51. /* DISPATCH_START */
  52. #define ROOT_UID    0
  53. #define ROOT_GID    0
  54. int
  55. (getuid)(void)
  56. {
  57.     return ROOT_UID;
  58. }
  59.  
  60. int
  61. (geteuid)(void)
  62. {
  63.     return ROOT_UID;
  64. }
  65.  
  66. int
  67. (getgid)(void)
  68. {
  69.     return ROOT_GID;
  70. }
  71.  
  72. int
  73. (getegid)(void)
  74. {
  75.     return ROOT_GID;
  76. }
  77.  
  78. int
  79. (setuid)(int uid)
  80. { 
  81.     return (uid==ROOT_UID?0:-1);
  82. }
  83.  
  84. int
  85. setgid(int gid)
  86. { 
  87.     return (gid==ROOT_GID?0:-1); 
  88. }
  89.  
  90. #undef execv
  91.  
  92. (execv)()
  93. {
  94.     croak("execv() not implemented on the Macintosh");
  95. }
  96.  
  97. #undef execvp
  98.  
  99. (execvp)()
  100. {
  101.     croak("execvp() not implemented on the Macintosh");
  102. }
  103.  
  104. kill()
  105. {
  106.     croak("kill() not implemented on the Macintosh");
  107. }
  108. /* DISPATCH_END */
  109.  
  110. char **environ;
  111. static    char *    gEnvpool;
  112. extern int StandAlone;
  113.  
  114. char ** init_env(char ** env)
  115. {
  116.     int        envcnt    =    0;
  117.     int        envsize    =    0;
  118.     int        varlen;
  119.     char *    envpool;
  120.     FILE *    envfile    =    0;
  121.     
  122.     for (envcnt = 0; env[envcnt]; envcnt++)    {
  123.         varlen    = strlen(env[envcnt]);
  124.         envsize    +=    varlen+strlen(env[envcnt]+varlen+1)+2;
  125.     }
  126.     
  127.     if (gEnvpool) {
  128.         Safefree(environ);
  129.         Safefree(gEnvpool);
  130.     }
  131.     
  132.     New(50, environ, envcnt+1, char *);
  133.     New(50, gEnvpool, envsize, char);
  134.     
  135.     envpool = gEnvpool;
  136.     for (envcnt = 0; env[envcnt]; envcnt++)    {
  137.         environ[envcnt]     = envpool;
  138.         varlen                = strlen(env[envcnt]);
  139.         strcpy(envpool, env[envcnt]);
  140.         envpool              += varlen+1;
  141.         envpool[-1]            = '=';
  142.         strcpy(envpool, env[envcnt]+varlen+1);
  143.         envpool              += strlen(env[envcnt]+varlen+1)+1;
  144.     }
  145.  
  146.     environ[envcnt] = 0;
  147.     
  148.     return environ;
  149. }    
  150.  
  151. void install_env(Handle env)
  152. {
  153.     int        envcnt    =    0;
  154.     int        envsize    =    0;
  155.     int        varlen;
  156.     char *    envpool;
  157.     char *     max;
  158.     char         state;
  159.     FILE *    envfile    =    0;
  160.     
  161.     if (gEnvpool) {
  162.         Safefree(environ);
  163.         Safefree(gEnvpool);
  164.     }
  165.  
  166.     New(50, gEnvpool, GetHandleSize(env), char);
  167.     
  168.     state = HGetState(env);
  169.     HLock(env);
  170.     BlockMove(*env, (Ptr)gEnvpool, GetHandleSize(env));
  171.     HSetState(env, state);
  172.     
  173.     envpool = gEnvpool;
  174.     max = envpool + GetHandleSize(env);
  175.     while (envpool < max) {
  176.         ++envcnt;
  177.         envpool += strlen(envpool)+1;
  178.     }
  179.     
  180.     New(50, environ, envcnt+1, char *);
  181.     
  182.     envpool = gEnvpool;
  183.     envcnt  = 0;
  184.     while (envpool < max) {
  185.         environ[envcnt++]     = envpool;
  186.         envpool                    += strlen(envpool)+1;
  187.     }
  188.  
  189.     environ[envcnt] = 0;
  190. }
  191.  
  192. Handle retrieve_env()
  193. {
  194.     char ** envp = environ;
  195.     Handle  env  = NewHandle(0);
  196.     
  197.     while (*envp) {
  198.         PtrAndHand(*envp, env, strlen(*envp)+1);
  199.         ++envp;
  200.     }
  201.     
  202.     return env;
  203. }
  204.  
  205. typedef struct PD {
  206.     struct PD *    next;
  207.     FILE *        tempFile;
  208.     FSSpec        pipeFile;
  209.     char *        execute;
  210.     long            status;
  211. } PipeDescr, *PipeDescrPtr;
  212.  
  213. static PipeDescrPtr    pipes        =    nil;
  214. static Boolean            sweeper    =    false;
  215.  
  216. void sweep()
  217. {
  218.     while (pipes)
  219.         my_pclose(pipes->tempFile);
  220.     sweeper = false;
  221. }
  222.  
  223. typedef struct WEPDesc {
  224.     struct WEPDesc *    next;
  225.     const char *                            command;
  226.     EmulationProc                             proc;
  227. } WEPDesc, * WEPDescPtr;
  228.  
  229. static WEPDescPtr         gEmulators[128];
  230. static Boolean            gHasEmulators = false;
  231.  
  232. void AddWriteEmulationProc(const char * command, EmulationProc proc)
  233. {
  234.     WEPDescPtr    wepdesc     = (WEPDescPtr) malloc(sizeof(WEPDesc));
  235.     
  236.     wepdesc->next             =     gEmulators[*command];
  237.     wepdesc->command        =    command;
  238.     wepdesc->proc            =    proc;
  239.     gEmulators[*command]    =    wepdesc;
  240. }
  241.  
  242. EmulationProc FindWriteEmulationProc(char * command, char ** rest)
  243. {
  244.     char *         end;
  245.     WEPDescPtr    queue;
  246.     
  247.     for (end = command; isalnum(*end); ++end);
  248.     
  249.     if (end == command || (*command & 0x80))
  250.         return nil;
  251.     
  252.     for (queue = gEmulators[*command]; queue; queue = queue->next)
  253.         if (!strncmp(command, queue->command, end-command))
  254.             if (!queue->command[end-command]) {
  255.                 while (isspace(*end))
  256.                     ++end;
  257.                 *rest = end;
  258.                 
  259.                 return queue->proc;
  260.             }
  261.     
  262.     return nil;
  263. }
  264.  
  265. static int EmulatePwd(FILE * tempFile, char * command)
  266. {
  267.     char curdir[256];
  268.     
  269.     if (!getcwd(curdir, 256)) 
  270.         return -1;
  271.     
  272.     fprintf(tempFile, "%s\n", curdir);
  273.     
  274.     return 0;
  275. }
  276.  
  277. static int EmulateHostname(FILE * tempFile, char * command)
  278. {
  279.     char curhostname[256];
  280.     
  281.     if (gethostname(curhostname, 256)) 
  282.         return -1;
  283.     
  284.     fprintf(tempFile, "%s\n", curhostname);
  285.     
  286.     return 0;
  287. }
  288.  
  289. static int EmulateGlob(FILE * tempFile, char * command)
  290. {
  291.     char             curbuf[256];
  292.     char *        curcmd;
  293.     Boolean        relativePath;
  294.     int            colonCount;
  295.     FileGlobRef    glob;
  296.     FSSpec         spec;
  297.     FSSpec        curDir;
  298.     
  299.     for (curcmd = curbuf; !isspace(*command); )
  300.         if (!(*curcmd++ = *command++))
  301.             break;
  302.  
  303.     if (!(glob = NewFileGlob(curbuf)))
  304.         return -1;
  305.     
  306.     relativePath = true;
  307.     
  308.     if (curbuf[0] == ':') {
  309.         /* Explicitely relative path, e.g. <:*.c> */
  310.         char     ch;
  311.         
  312.         for (curcmd = curbuf+1; *curcmd == ':'; ++curcmd)
  313.             ;
  314.         
  315.         ch             = *curcmd; 
  316.         *curcmd        = 0;
  317.         Path2FSSpec(curbuf, &curDir);
  318.         *curcmd        = ch;
  319.         colonCount     =    curcmd - curbuf;
  320.     } else if (!strchr(curbuf, ':')) {
  321.         /* Implicitely relative path, e.g. <*.c> */
  322.         colonCount     =     0;
  323.         Path2FSSpec(":", &curDir);
  324.     } else
  325.         relativePath = false;
  326.         
  327.     while (FileGlob2FSSpec(glob, &spec)) {
  328.         if (relativePath) {
  329.             curcmd = FSp2DirRelPath(&spec, &curDir);
  330.             if (colonCount) {
  331.                 int i = colonCount - (*curcmd == ':');
  332.                 while (i--)
  333.                     putc(':', tempFile);
  334.             }
  335.         } else
  336.             curcmd = FSp2FullPath(&spec);
  337.         
  338.         fprintf(tempFile, "%s\n", curcmd);
  339.         NextFileGlob(glob);
  340.     }
  341.     DisposeFileGlob(glob);
  342.     
  343.     return 0;
  344. }
  345.  
  346. FILE * my_popen(char * command, char * mode)
  347. {
  348.     PipeDescrPtr    pipe;
  349.     
  350.     if (!gHasEmulators) {
  351.         gHasEmulators = true;
  352.         AddWriteEmulationProc("pwd", EmulatePwd);
  353.         AddWriteEmulationProc("directory", EmulatePwd);
  354.         AddWriteEmulationProc("Directory", EmulatePwd);
  355.         AddWriteEmulationProc("hostname", EmulateHostname);
  356.         AddWriteEmulationProc("glob", EmulateGlob);
  357.     }
  358.     
  359.     if (!strcmp(command, "-"))
  360.         croak("Implicit fork() on a Mac? No forking chance");
  361.     
  362.     New(666, pipe, 1, PipeDescr);
  363.     
  364.     if (!pipe)
  365.         return NULL;
  366.         
  367.     if (FSpMakeTempFile(&pipe->pipeFile))
  368.         goto failed;
  369.     pipe->execute    =    nil;
  370.     
  371.     switch(*mode)    {
  372.     case 'r':
  373.         {
  374.             /* Ugh ! A hardcoded command  ! */
  375.             EmulationProc proc = FindWriteEmulationProc(command, &command);
  376.             
  377.             if (proc) {
  378.                 if (!(pipe->tempFile    = fopen(FSp2FullPath(&pipe->pipeFile), "w")))
  379.                     goto delete;
  380.                 if (proc(pipe->tempFile, command))
  381.                     goto delete;
  382.                 fclose(pipe->tempFile);
  383.             } else if (SubLaunch(command, nil, &pipe->pipeFile, &pipe->pipeFile, &pipe->status))
  384.                 goto delete;
  385.             
  386.             if (!(pipe->tempFile    = fopen(FSp2FullPath(&pipe->pipeFile), "r")))
  387.                 goto delete;
  388.             break;
  389.         }
  390.     case 'w':
  391.         New(667, pipe->execute, strlen(command)+1, char);
  392.         if (!pipe->execute || !(pipe->tempFile    = fopen(FSp2FullPath(&pipe->pipeFile), "w")))
  393.             goto delete;
  394.         strcpy(pipe->execute, command);
  395.         break;
  396.     }
  397.     
  398.     pipe->next    =    pipes;
  399.     pipes            =    pipe;
  400.     
  401.     if (!sweeper)    {
  402.         atexit(sweep);
  403.         sweeper    =    true;
  404.     }
  405.  
  406.     return pipe->tempFile;
  407. delete:
  408.     if (pipe->execute)
  409.         Safefree(pipe->execute);
  410.     HDelete(pipe->pipeFile.vRefNum, pipe->pipeFile.parID, pipe->pipeFile.name);
  411. failed:
  412.     Safefree(pipe);
  413.     
  414.     return NULL;
  415. }
  416.  
  417. int my_pclose(FILE *    f)
  418. {
  419.     OSErr                err;
  420.     PipeDescrPtr *    prev;
  421.     PipeDescrPtr    pipe;
  422.     
  423.     for (prev = (PipeDescrPtr *) &pipes; pipe = *prev; prev = &pipe->next)
  424.         if (pipe->tempFile == f)
  425.             break;
  426.     
  427.     if (!pipe)
  428.         return -1;
  429.     
  430.     *prev = pipe->next;
  431.     
  432.     fclose(f);
  433.     
  434.     if (pipe->execute)
  435.         err = SubLaunch(pipe->execute, &pipe->pipeFile, nil, nil, &pipe->status);
  436.     else
  437.         err = noErr;
  438.         
  439.     HDelete(pipe->pipeFile.vRefNum, pipe->pipeFile.parID, pipe->pipeFile.name);
  440.     if (pipe->execute)
  441.         Safefree(pipe->execute);
  442.     Safefree(pipe);
  443.     
  444.     return err? -1 : (int) pipe->status;    
  445. }
  446.  
  447. #undef TUNESPIN
  448.  
  449. void SpinMacCursor()
  450. {
  451.     static long lastSpin = 0;
  452.     static long lastAevt = 0;
  453. #ifdef TUNESPIN
  454.     static long numSpins = 0;
  455. #endif
  456.     long            curSpin    = LMGetTicks();
  457.  
  458. #ifdef TUNESPIN
  459.     ++numSpins;
  460. #endif
  461.     if (curSpin - lastSpin < 5)
  462.         return;
  463.     
  464. #ifdef TUNESPIN
  465.     printf("%d %d, ", curSpin, numSpins);
  466. #endif
  467.     lastSpin = curSpin;
  468.     
  469.     sleep(0);
  470.     
  471.     if (!StandAlone && curSpin - lastAevt > 30) {
  472.         /* Newer versions of the MPW Shell disable automatic processing of
  473.            AppleEvents, but we want them!
  474.         */
  475.         EventRecord ev;
  476.         
  477.         lastAevt = curSpin;
  478.         if (WaitNextEvent(highLevelEventMask, &ev, 0, nil)) {
  479.              AEProcessAppleEvent(&ev);    /* Ignore errors */
  480.              lastAevt -= 25;                 /* Retry sooner if successful */
  481.         }
  482.     }
  483. }
  484.  
  485. /* DISPATCH_START */
  486. struct tm *localtime(const time_t *tp)
  487.     {
  488.     DateTimeRec dtr;
  489.     MachineLocation loc;
  490.     static struct tm statictime;
  491.     static const short monthday[12] =
  492.         {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
  493.  
  494.     Secs2Date(*tp, &dtr);
  495.     statictime.tm_sec = dtr.second;
  496.     statictime.tm_min = dtr.minute;
  497.     statictime.tm_hour = dtr.hour;
  498.     statictime.tm_mday = dtr.day;
  499.     statictime.tm_mon = dtr.month - 1;
  500.     statictime.tm_year = dtr.year - 1900;
  501.     statictime.tm_wday = dtr.dayOfWeek - 1;
  502.     statictime.tm_yday = monthday[statictime.tm_mon]
  503.         + statictime.tm_mday - 1;
  504.     if (1 < statictime.tm_mon && !(statictime.tm_year & 3))
  505.         ++statictime.tm_yday;
  506.     ReadLocation(&loc);
  507.     if (!loc.latitude && !loc.longitude)
  508.         statictime.tm_isdst = -1;
  509.     else
  510.         statictime.tm_isdst = (loc.u.dlsDelta & 0x80) != 0;
  511.     return(&statictime);
  512. }
  513.  
  514. struct tm * gmtime(const time_t * timer)
  515. {
  516.     MachineLocation     loc;
  517.     long                    delta;
  518.     time_t                rolex;
  519.     
  520.     ReadLocation(&loc);
  521.     
  522.     if (!loc.latitude && !loc.longitude)
  523.         return localtime(timer);    /* This is incorrect unless you live in Greenwich */
  524.     
  525.     delta = loc.u.gmtDelta & 0xFFFFFF;
  526.     
  527.     if (delta & 0x800000)
  528.         delta = (long) ((unsigned long) delta | 0xFF000000);
  529.         
  530.     rolex = (unsigned long) ((long) *timer - delta);
  531.     
  532.     return localtime(&rolex);
  533.  }
  534. /* DISPATCH_END */
  535.  
  536. clock_t mac_times(struct tms * t)
  537. {
  538.     t->tms_utime = clock() - gStartClock;
  539.     t->tms_stime = 0;
  540.     t->tms_cutime = 0;
  541.     t->tms_cstime = 0;
  542.     
  543.     return t->tms_utime;
  544. }
  545.  
  546. #undef atof
  547.  
  548. double mac_atof(const char * nptr)
  549. {
  550.     /* The Mac returns NaN(17) on undefined strings, which is not acceptable
  551.        for Perl
  552.     */
  553.     double res = atof(nptr);
  554.     
  555.     if (isnan(res) /* This doesn't work: && res == nan("17") */)
  556.         return 0.0;
  557.     else
  558.         return res;
  559. }
  560.  
  561. void CopyC2PStr(char * cstr, StringPtr pstr)
  562. {
  563.     int    len;
  564.     
  565.     for (len = 0; *cstr && len<256; )
  566.         pstr[++len] = *cstr++;
  567.     
  568.     pstr[0] = len;
  569. }
  570.  
  571.  
  572. char * MPWFileName(char * file)
  573. {
  574.     if (!strcmp(file, "Dev:Pseudo"))
  575.         return gPseudoFileName;
  576.     else if (!strncmp(file, "Dev:Pseudo:", 11))
  577.         return file + 11;
  578.     else
  579.         return file;
  580. }
  581.  
  582. static Boolean sPosCommit = true;
  583.  
  584. char * MPWPosIndication(char * buf, char * file, long line)
  585. {
  586.     file = MPWFileName(file);
  587.  
  588.     if (!sPosCommit)
  589.        gFirstErrorLine = -1;
  590.         
  591.     if (gFirstErrorLine == -1 && !Path2FSSpec(file, &gFirstErrorFile)) {
  592.         gFirstErrorLine = line;
  593.         sPosCommit      = false;
  594.      }
  595.     
  596.     strcpy(buf, "File '"); 
  597.     buf += 6;
  598.     
  599.     while (*file) 
  600.         if (*file == '\'') {
  601.         strcpy(buf, "'∂''");
  602.         buf += 3;
  603.         ++file;
  604.     } else
  605.         *buf++ = *file++;
  606.         
  607.     if (buf[-1] == '\'' && buf[-2] == '\'')
  608.         --buf;
  609.     else
  610.         *buf++ = '\'';
  611.  
  612.     return buf + sprintf(buf, "; Line %ld", line);
  613. }
  614.  
  615. void     MPWPosCommit()
  616. {
  617.     sPosCommit = true;
  618. }
  619.  
  620. int OverrideExtract(char * origname)
  621. {
  622.     char         file[256];
  623.     
  624.     strcpy(file+1, MPWFileName(origname));
  625.     file[0] = strlen(file+1);
  626.     ParamText((StringPtr) file, "\p", "\p", "\p");
  627.     
  628.     return Alert(270, (ModalFilterUPP) nil) == 1;
  629. }
  630.  
  631. #define STACK_INTERVENTION_LIMIT    8192
  632.  
  633. void StackAttack()
  634. {
  635.     if (StackSpace() < STACK_INTERVENTION_LIMIT)
  636.         croak("Stack space getting low ! Aborting script for your own good...\n");
  637. }
  638.  
  639. void mac_initminiperl()
  640. {
  641.     if (!gAppDir) {
  642.         InitGraf((Ptr) &qd.thePort);
  643.         signal(SIGINT, SIG_DFL);
  644.     }
  645.     
  646.     gStartClock      = LMGetTicks();
  647. }
  648.  
  649. /* DISPATCH_START */
  650. pid_t (getpid)()
  651. {
  652.     return 1;
  653. }
  654. /* DISPATCH_END */
  655.  
  656. void SIOUXHandleOneEvent()
  657. {
  658.     Debugger();
  659. }
  660.  
  661. void InstallConsole()
  662. {
  663.     Debugger();
  664. }
  665.  
  666. void WriteCharsToConsole()
  667. {
  668.     Debugger();
  669. }
  670.  
  671. void ReadCharsFromConsole()
  672. {
  673.     Debugger();
  674. }
  675.